////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
// Copyright (c) 2017-2018 Qualcomm Technologies, Inc.
// All Rights Reserved.
// Confidential and Proprietary - Qualcomm Technologies, Inc.
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/// THIS IS AUTO-GENERATED CODE.  PLEASE DO NOT EDIT (File bug reports against tools).
///
/// Auto-generated by: ParameterParser V1.1.4
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/// @file  afcontrastafelements.h
/// @brief Auto-generated Chromatix parameter file
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

#ifndef AFCONTRASTAFELEMENTS_H
#define AFCONTRASTAFELEMENTS_H

#include "parametermodule.h"
#include "parameterfilesymboltable.h"
#include "parametertypes.h"
#include "afglobalelements.h"

#define AFCONTRASTAFELEMENTS_NAMESPACE_BEGIN namespace afcontrastafelements {
#define AFCONTRASTAFELEMENTS_NAMESPACE_END }

AFCONTRASTAFELEMENTS_NAMESPACE_BEGIN

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/// chromatixBAFExposureCompensation
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
struct chromatixBAFExposureCompensation
{

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// exposureCompensationEnable
    ///
    /// Description:   Flag to enable/disable the exposure compensation feature. This feature stretch BAF gamma LUT to
    ///                compensate the exposure change of sensor.
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    afglobalelements::enable_flag_type exposureCompensationEnable;

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// kickinProgress
    ///
    /// Description:   Value to decide when the exposure compensate feature start, once the HAF output progress equal or larger
    ///                than this value, the exposure compensate feature will start as long as the feature is enabled.
    /// Range:         [0,100]
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    INT32            kickinProgress;
};

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/// chromatixAFMiscellaneousType
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
struct chromatixAFMiscellaneousType
{

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// peakDetectInDecreaseEnable
    ///
    /// Description:   It makes Peak detection enables or not in decrease pattern. If the poor HW is used, the performance can
    ///                be low. In case of this, we can set 0 to disable detecting peak in decrease pattern.
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    afglobalelements::enable_flag_type peakDetectInDecreaseEnable;

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// frameSkipGoToPeak
    ///
    /// Description:   Frame count being skipped. It makes frame be skipped in case going to peak. It's for returing AF status
    ///                after lens moves to the target position completely. Also, it's for preventing ZSL shot is taken during
    ///                the lens movement is not completed.
    /// Range:         [0,unbounded]
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    INT32            frameSkipGoToPeak;

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// forceEnableFineSearch
    ///
    /// Description:   It makes forcing to do fine search, or not even in case normal CAF. The previous concepts enables fine
    ///                search only in the case of CAF of normal mode, not video. Regardless of the mode, if it's enabled we can
    ///                do force fine search with in CAF, only in case of peak is found at first 4 frames.
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    afglobalelements::enable_flag_type forceEnableFineSearch;

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// optimizePrescan
    ///
    /// Description:   It makes pre scan be optimized with some code cleaning. It's already verified on customer projects.
    ///                Because some pre-scan operation is changed if we apply this, we make this be configurable as tunable
    ///                factor.
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    afglobalelements::enable_flag_type optimizePrescan;

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// optimizePeakEnable
    ///
    /// Description:   It's about another optimization changes for performance. It's also already verified on customer projects.
    ///                With same reason of AFChromatixOptimize_PRESCAN, we make this be configurable as tunable factor.
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    afglobalelements::enable_flag_type optimizePeakEnable;
};

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/// chromatixAFTuningFullsweep
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
struct chromatixAFTuningFullsweep
{

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// numStepsBetweenStatPoints
    ///
    /// Description:   Used to control how many steps to move the lens at a time during search. Effect: Should always be 1, but
    ///                for some tests could be more.
    /// Range:         [0,unbounded]
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    INT32            numStepsBetweenStatPoints;

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// frameDelayInf
    ///
    /// Description:   Number of frames to skip after lens move to initial (inf) position. Effect: Bigger value will give more
    ///                time for the lens to settle after going into the inf. position.
    /// Range:         [0,10]
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    INT32            frameDelayInf;

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// frameDelayNorm
    ///
    /// Description:   Number of frames to skip after lens move to the next position. Effect: Bigger value will give more time
    ///                for the lens to settle between steps.
    /// Range:         [0,10]
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    INT32            frameDelayNorm;

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// frameDelayFinal
    ///
    /// Description:   Number of frames to skip after lens move to its final position where the maximum FV is registered.
    ///                Effect: Bigger value will give more time for the lens to settle after going into the final position, so
    ///                the FV can be observed in the logs.
    /// Range:         [0,10]
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    INT32            frameDelayFinal;

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// previewAssistedAFEnable
    ///
    /// Description:   Flag to enable PAAF during Fullsweep.
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    afglobalelements::enable_flag_type previewAssistedAFEnable;
};

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/// chromatixStepSize
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
struct chromatixStepSize
{

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// region0
    ///
    /// Description:   Step size for far end to rgn 0 boundary. Data range: 0 to far end lens position.
    /// Range:         [0,unbounded]
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    UINT32 region0;

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// region1
    ///
    /// Description:   Step size for rgn 0 to rgn 1 boundary. Data range: 0 to far end lens position.
    /// Range:         [0,unbounded]
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    UINT32 region1;

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// region2
    ///
    /// Description:   Step size for rgn 1 to rgn 2 boundary. Data range: 0 to far end lens position.
    /// Range:         [0,unbounded]
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    UINT32 region2;

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// region3
    ///
    /// Description:   Step size for rgn 2 to rgn 3 boundary. Data range: 0 to far end lens position.
    /// Range:         [0,unbounded]
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    UINT32 region3;

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// region4
    ///
    /// Description:   Step size for rgn 3 to near end boundary. Data range: 0 to far end lens position.
    /// Range:         [0,unbounded]
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    UINT32 region4;
};

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/// chromatixStepSizeTable
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
struct chromatixStepSizeTable
{

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// prescanNormalLight
    ///
    /// Description:   Prescan step size for normal light. Default value: {20, 12, 12, 12, 16}. Data range: 0 to far end lens
    ///                position. Effect: Higher number increase speed of search, but lower accuracy. Setting too high of scan
    ///                step will have adverse effect on actuator movement and result in bad stats.
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    chromatixStepSize prescanNormalLight;

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// prescanLowLight
    ///
    /// Description:   Prescan step size for normal light. Default value: {20, 12, 12, 12, 16}. Data range: 0 to far end lens
    ///                position. Effect: Higher number increase speed of search, but lower accuracy. Setting too high of scan
    ///                step will have adverse effect on actuator movement and result in bad stats.
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    chromatixStepSize prescanLowLight;

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// finescanNormalLight
    ///
    /// Description:   Fine scan step size for normal light. Default value: {10, 7, 6, 6, 10}. Data range: 0 to far end lens
    ///                position. Effect: Higher number increase speed of search, but lower accuracy. Setting too high of scan
    ///                step will have adverse effect on actuator movement and result in bad stats.
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    chromatixStepSize finescanNormalLight;

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// finescanLowLight
    ///
    /// Description:   Fine scan step size for low light. Default value: {12, 9, 8, 9, 12}. Data range: 0 to far end lens
    ///                position. Effect: Higher number increase speed of search, but lower accuracy. Setting too high of scan
    ///                step will have adverse effect on actuator movement and result in bad stats.
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    chromatixStepSize finescanLowLight;
};

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/// chromatixBVThreshold
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
struct chromatixBVThreshold
{

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// Threshold - Array
    ///
    /// Range:         [0.5,1]
    /// Length:        8
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    FLOAT Threshold[8];
};

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/// chromatixSingleThreshold
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
struct chromatixSingleThreshold
{

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// changeRatioInc
    ///
    /// Description:   Threshold for detecting INCREASE trend from two points of SW stats. Effect: Higher value makes detection
    ///                harder, but lower values has adverse effect of considering the trend as Flat.
    /// Range:         [1.0,1.1]
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    FLOAT                changeRatioInc;

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// changeRatioDec
    ///
    /// Description:   Threshold for detecting DECREASE trend from two points of SW stats. Effect: Lower value makes detection
    ///                harder, but higher values has adverse effect of considering the trend as Flat.
    /// Range:         [0.5,1.0]
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    FLOAT                changeRatioDec;

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// flatIncThres
    ///
    /// Description:   Threshold for detect flat trend in INCREASE. Effect: Lower value makes detection harder.
    /// Range:         [1.0,1.1]
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    FLOAT                flatIncThres;

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// flatDecThres
    ///
    /// Description:   Threshold for detect flat trend in DECREASE. Effect: Lower value makes detection harder.
    /// Range:         [0.5,1.0]
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    FLOAT                flatDecThres;

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// macroThres
    ///
    /// Description:   Threshold for detect Macro Peak. Effect: Lower value makes detection harder.
    /// Range:         [0.5,1.0]
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    FLOAT                macroThres;

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// dropThres
    ///
    /// Description:   Threshold for large drop in invalid trend. Effect: Lower value makes detection harder.
    /// Range:         [0.5,1.0]
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    FLOAT                dropThres;

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// histogramDecreaseDecreaseThreshold
    ///
    /// Description:   Histogram threshold to detect peak in decrease decrease trend. Effect: Lower value makes detection
    ///                harder.
    /// Range:         [0,unbounded]
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    UINT32               histogramDecreaseDecreaseThreshold;

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// histogramIncreaseDecreaseThreshold
    ///
    /// Description:   Histogram threshold to detect peak in increase decrease trend. Effect: Lower value makes detection
    ///                harder.
    /// Range:         [0,unbounded]
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    UINT32               histogramIncreaseDecreaseThreshold;

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// threeFrameDecreaseDecreasePeakThreshold
    ///
    /// Description:   Threshold in 3 frame decrease decrease peak. Default value: {0.97f, 0.97f, 0.97f, 0.97f, 0.97f, 0.97f,
    ///                0.97f, 0.97f}. Effect: Lower value makes detection harder.
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    chromatixBVThreshold threeFrameDecreaseDecreasePeakThreshold;

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// threeFrameIncreaseDecreasePeakThreshold
    ///
    /// Description:   Threshold in 3 frame increase decrease peak. Default value: {0.97f, 0.97f, 0.97f, 0.97f, 0.97f, 0.97f,
    ///                0.97f, 0.97f}. Effect: Lower value makes detection harder.
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    chromatixBVThreshold threeFrameIncreaseDecreasePeakThreshold;

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// decreaseDecreasePeakThreshold
    ///
    /// Description:   Threshold in decrease decrease peak. Default value: {0.97f, 0.97f, 0.97f, 0.97f, 0.97f, 0.97f, 0.97f,
    ///                0.97f}. Effect: Lower value makes detection harder.
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    chromatixBVThreshold decreaseDecreasePeakThreshold;

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// decreaseDecreasePeakWithNoiseThreshold
    ///
    /// Description:   Threshold in decrease decrease peak with noise present. Default value: {0.97f, 0.97f, 0.97f, 0.97f,
    ///                0.97f, 0.97f, 0.97f, 0.97f}. Effect: Lower value makes detection harder.
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    chromatixBVThreshold decreaseDecreasePeakWithNoiseThreshold;

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// increaseDecreasePeakThreshold
    ///
    /// Description:   Threshold in increase decrease peak. Default value: {0.97f, 0.97f, 0.97f, 0.97f, 0.97f, 0.97f, 0.97f,
    ///                0.97f}. Effect: Lower value makes detection harder.
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    chromatixBVThreshold increaseDecreasePeakThreshold;

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// increaseDecreasePeakWithNoiseThreshold
    ///
    /// Description:    Threshold in increase decrease peak with noise present. Default value: {0.97f, 0.97f, 0.97f, 0.97f,
    ///                0.97f, 0.97f, 0.97f, 0.97f}. Effect: Lower value makes detection harder.
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    chromatixBVThreshold increaseDecreasePeakWithNoiseThreshold;

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// flatThreshold
    ///
    /// Description:   Default value: {0.97f, 0.97f, 0.97f, 0.97f, 0.97f, 0.97f, 0.97f, 0.97f}. Effect: Lower value makes
    ///                detection harder.
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    chromatixBVThreshold flatThreshold;
};

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/// chromatixFVScoreThreshold
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
struct chromatixFVScoreThreshold
{

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// defaultStats
    ///
    /// Description:   Index to specify default stats type Do not modify unless it causes issues. Effect: Affects Stats
    ///                selection.
    /// Range:         [0,2]
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    INT32                defaultStats;

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// scoreRatioShowDif
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    chromatixBVThreshold scoreRatioShowDif;

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// strictNoise
    ///
    /// Description:   Noise value for strictly noise. Do not modify unless it causes issues. Affects Stats selection.
    /// Range:         [0.0,1.0]
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    FLOAT                strictNoise;

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// normalNoise
    ///
    /// Description:   Noise value for normal noise. Do not modify unless it causes issues. Effect: Affects Stats selection.
    /// Range:         [0.0,1.0]
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    FLOAT                normalNoise;

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// lighttNoise
    ///
    /// Description:   Noise value for light noise. Do not modify unless it causes issues. Effect: Affects Stats selection.
    /// Range:         [0.0,1.0]
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    FLOAT                lighttNoise;

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// strongPeakThres
    ///
    /// Description:   Threshold for number of strong peak. Do not modify unless it causes issues. Effect: Affects Stats
    ///                selection.
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    INT32                strongPeakThres;

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// strongIncThres
    ///
    /// Description:   Threshold for number of strong increase. Do not modify unless it causes issues. Effect: Affects Stats
    ///                selection.
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    INT32                strongIncThres;

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// strongDecThres
    ///
    /// Description:   Threshold for number of strong decrease Do not modify unless it causes issues. Effect: Affects Stats
    ///                selection.
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    INT32                strongDecThres;
};

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/// chromatixSingleOptic
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
struct chromatixSingleOptic
{

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// CAFFarEnd
    ///
    /// Description:   Far end search limit for CAF. Default value: SINGLE_INF_LIMIT_IDX. Data range: SINGLE_NEAR_LIMIT_IDX -
    ///                SINGLE_INF_LIMIT_IDX. Constraints: Logically place these indexes.
    /// Range:         [0,10000]
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    UINT32 CAFFarEnd;

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// CAFNearEnd
    ///
    /// Description:   Near end search limit for CAF. Default value: SINGLE_NEAR_LIMIT_IDX. Data range: SINGLE_NEAR_LIMIT_IDX -
    ///                SINGLE_INF_LIMIT_IDX. Constraints: Logically place these indexes.
    /// Range:         [0,10000]
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    UINT32 CAFNearEnd;

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// TAFFarEnd
    ///
    /// Description:   Far end search limit for TAF. Default value: SINGLE_INF_LIMIT_IDX. Data range: SINGLE_NEAR_LIMIT_IDX -
    ///                SINGLE_INF_LIMIT_IDX. Constraints: Logically place these indexes.
    /// Range:         [0,10000]
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    UINT32 TAFFarEnd;

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// TAFNearEnd
    ///
    /// Description:   Near end search limit for TAF. Default value: SINGLE_NEAR_LIMIT_IDX. Data range: SINGLE_NEAR_LIMIT_IDX -
    ///                SINGLE_INF_LIMIT_IDX. Constraints: Logically place these indexes.
    /// Range:         [0,10000]
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    UINT32 TAFNearEnd;

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// searchRegion1
    ///
    /// Description:   Region boundary for non linear region for far end. Default value: SINGLE_50CM_IDX. Data range:
    ///                SINGLE_NEAR_LIMIT_IDX - SINGLE_INF_LIMIT_IDX. Constraints: Logically place these indexes. Effect: Lower
    ///                value makes detection harder.
    /// Range:         [0,10000]
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    UINT32 searchRegion1;

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// searchRegion2
    ///
    /// Description:   Region boundary for linear region. Default value: SINGLE_20CM_IDX. Data range: SINGLE_NEAR_LIMIT_IDX -
    ///                SINGLE_INF_LIMIT_IDX. Constraints: Logically place these indexes.
    /// Range:         [0,10000]
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    UINT32 searchRegion2;

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// searchRegion3
    ///
    /// Description:   Variable name: srch_rgn_3. Region boundary for non linear region for near end. Default value:
    ///                SINGLE_14CM_IDX. Data range: SINGLE_NEAR_LIMIT_IDX - SINGLE_INF_LIMIT_IDX. Constraints: Logically place
    ///                these indexes.
    /// Range:         [0,10000]
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    UINT32 searchRegion3;

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// fineSearchRegion
    ///
    /// Description:   Boundary to use fine search from far end. Default value: SINGLE_50CM_IDX. Data range:
    ///                SINGLE_NEAR_LIMIT_IDX - SINGLE_INF_LIMIT_IDX. Constraints: Logically place these indexes.
    /// Range:         [0,10000]
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    UINT32 fineSearchRegion;

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// farZone
    ///
    /// Description:   Zone boundary to consider far end for starting location. Default value: SINGLE_INF_LIMIT_IDX. Data range:
    ///                SINGLE_NEAR_LIMIT_IDX - SINGLE_INF_LIMIT_IDX. Constraints: Logically place these indexes.
    /// Range:         [0,10000]
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    UINT32 farZone;

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// nearZone
    ///
    /// Description:   Zone boundary to consider near end for starting location. Default value: SINGLE_10CM_IDX. Data range:
    ///                SINGLE_NEAR_LIMIT_IDX - SINGLE_INF_LIMIT_IDX. Constraints: Logically place these indexes.
    /// Range:         [0,10000]
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    UINT32 nearZone;

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// midZone
    ///
    /// Description:   Boundary to consider middle zone (middle of far and near). Default value: SINGLE_60CM_IDX. Data range:
    ///                SINGLE_NEAR_LIMIT_IDX - SINGLE_INF_LIMIT_IDX. Constraints: Logically place these indexes.
    /// Range:         [0,10000]
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    UINT32 midZone;

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// farStartPosition
    ///
    /// Description:   Default value: SINGLE_HYP_F_IDX. Data range: SINGLE_NEAR_LIMIT_IDX - SINGLE_INF_LIMIT_IDX. Constraints:
    ///                Logically place these indexes.
    /// Range:         [0,10000]
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    UINT32 farStartPosition;

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// nearStartPosition
    ///
    /// Description:    Default value: SINGLE_10CM_IDX. Data range: SINGLE_NEAR_LIMIT_IDX - SINGLE_INF_LIMIT_IDX. Constraints:
    ///                Logically place these indexes.
    /// Range:         [0,10000]
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    UINT32 nearStartPosition;

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// initialPosition
    ///
    /// Description:   Initial search position for the first search. Default value: SINGLE_HYP_F_IDX. Data range:
    ///                SINGLE_NEAR_LIMIT_IDX - SINGLE_INF_LIMIT_IDX. Constraints: Logically place these indexes.
    /// Range:         [0,10000]
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    UINT32 initialPosition;
};

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/// chromatixAFSingleFrameDelay
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
struct chromatixAFSingleFrameDelay
{

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// baseFrameDelay
    ///
    /// Description:   Number of frames to skip after lens move to start position. Effect: Bigger value will give more time for
    ///                the lens to settle hence KPI will increase.
    /// Range:         [0,10]
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    UINT32 baseFrameDelay;

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// coarseFrameDelay
    ///
    /// Description:   Number of frames to skip during Coarse search of AF. Effect: Bigger value will give more time for the
    ///                lens to settle between steps giving better FV, hence KPI will increase.
    /// Range:         [0,10]
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    UINT32 coarseFrameDelay;

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// fineFrameDelay
    ///
    /// Description:   Number of frames to skip during Fine search of AF. Effect: Bigger value will give more time for the lens
    ///                to settle between steps giving better FV, hence KPI will increase.
    /// Range:         [0,10]
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    UINT32 fineFrameDelay;
};

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/// singleIndex
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
enum class singleIndex
{
    SINGLE_NEAR_LIMIT_IDX = 0,
    SINGLE_7CM_IDX        = 1,
    SINGLE_10CM_IDX       = 2,
    SINGLE_14CM_IDX       = 3,
    SINGLE_20CM_IDX       = 4,
    SINGLE_30CM_IDX       = 5,
    SINGLE_40CM_IDX       = 6,
    SINGLE_50CM_IDX       = 7,
    SINGLE_60CM_IDX       = 8,
    SINGLE_120CM_IDX      = 9,
    SINGLE_HYP_F_IDX      = 10,
    SINGLE_INF_LIMIT_IDX  = 11,
    SINGLE_MAX_IDX        = 12
};

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/// chromatixAFTuningSingle
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
struct chromatixAFTuningSingle
{

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// index - Array
    ///
    /// Description:   Index mapping from physical distance to lens position. Data range: 0 to far end lens index. Constraints:
    ///                Refer to the tuning guide document on how to tune these paramters. Effect: Determines boundaries of
    ///                decision in Single AF algo. NOTE: It recommended to the total movable logical lens position range as [0 -
    ///                399] inorder to have same logical lens position across multiple actuators and sensors.
    /// Range:         [0,unbounded]
    /// Min Length:    1
    /// Max Length:    12
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    UINT32                      indexCount;
    UINT32                      indexID;
    UINT32*                     index;

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// actuatorType
    ///
    /// Description:    Type of Actuator used in camera module. Data range: ACT_TYPE_OPENLOOP(1) or ACT_TYPE_CLOSELOOP(0).
    ///                Effect: Affects behaviors in algorithm.
    /// Range:         [0,1]
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    UINT32                      actuatorType;

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// isHysteresisCompensationNeeded
    ///
    /// Description:   Flag to indicate if needed hysteresis, depending on actuator. Effect: Affects behaviors in algorithm.
    /// Range:         [0,1]
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    UINT32                      isHysteresisCompensationNeeded;

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// stepIndexPerMicroMeter
    ///
    /// Description:   Number of step index per micro-meter.
    /// Range:         [1,65535]
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    UINT32                      stepIndexPerMicroMeter;

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// previewAssistedAFEnable
    ///
    /// Description:   Enable flag to use SW stats. It is up to Algo to decide whether to enable sw stats in the end. For some
    ///                modes in Video use case we cannot enable SW stats. Effect: Setting 0 will use HW stats.
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    afglobalelements::enable_flag_type            previewAssistedAFEnable;

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// TAFStepTable
    ///
    /// Description:   Scan Step size for Touch AF
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    chromatixStepSizeTable      TAFStepTable;

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// CAFStepTable
    ///
    /// Description:   Scan Step size for Continuous AF
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    chromatixStepSizeTable      CAFStepTable;

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// software
    ///
    /// Description:   Set of algorithm Thresholds to find peak len position.
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    chromatixSingleThreshold    software;

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// hardware
    ///
    /// Description:   Set of algorithm Thresholds to find peak len position.
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    chromatixSingleThreshold    hardware;

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// optics
    ///
    /// Description:   _single_optic_t contains all the optic information for setting up boundary for search regions in terms of
    ///                lens position index measured.
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    chromatixSingleOptic        optics;

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// FVScoreThreshold
    ///
    /// Description:   Set of algorithm thresholds for single AF to find peak len position. Note: This feature is currently not
    ///                supported in 310 header so no need to tune the below parameters.
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    chromatixFVScoreThreshold   FVScoreThreshold;

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// frameDelay
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    chromatixAFSingleFrameDelay frameDelay;

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// BVGain - Array
    ///
    /// Description:   Gain thresholds to determine BV Lux level. Default value: [-30.0f, -0.50f, 0.50f, 1.50f, 2.50f, 3.20f,
    ///                6.00f, 8.00f]. Constraints: Do not modify unless it causes issues. Effect: Changes Lux Level decision.
    /// Range:         [unbounded,unbounded]
    /// Length:        8
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    FLOAT                       BVGain[8];

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// ignoreFirstInvalidFrame
    ///
    /// Description:   Enable flag to Determine the first frame as valid or not.like we can skip the first fv value for the
    ///                reverse search
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    afglobalelements::enable_flag_type            ignoreFirstInvalidFrame;
};

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/// chromatixAFSpotlightReserveType
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
struct chromatixAFSpotlightReserveType
{

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// enableSpotlightFilterSwitch
    ///
    /// Description:   A setting to turn on spotlight filter switch logic which can switch to a specific spot light filter when
    ///                detecting spot light scene. Constraints: the function needs enable with spot light scene detection.
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    afglobalelements::enable_flag_type enableSpotlightFilterSwitch;

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// secondOrderSpotlightFilterCoefficients - Array
    ///
    /// Description:   Second-order spotlight filter coefficients [10]. Description: Spotlight filter listed on BAF tuning
    ///                document. Constraints: need to check which sensor mode (zsl mode, non-zsl/binning mode) you are using and
    ///                fill in suitable filter coefficient, refer to the tuning guide document under BAF settings for more
    ///                details.
    /// Range:         [-5,5]
    /// Length:        10
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    FLOAT            secondOrderSpotlightFilterCoefficients[10];

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// fourthOrderSpotlightFilterCoefficients - Array
    ///
    /// Description:   Fourth-order spotlight filter coefficients [10]. Description: Spotlight filter listed on BAF tuning
    ///                document. Constraints: need to check which sensor mode (zsl mode, non-zsl/binning mode) you are using and
    ///                fill in suitable filter coefficient, refer to the tuning guide document under BAF settings for more
    ///                details.
    /// Range:         [-5,5]
    /// Length:        10
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    FLOAT            fourthOrderSpotlightFilterCoefficients[10];
};

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/// chromatixRegionTableType
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
struct chromatixRegionTableType
{

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// numEntries
    ///
    /// Description:   Number of table entry
    /// Range:         [0,100]
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    UINT32 numEntries;

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// weight - Array
    ///
    /// Description:   weight value for this entry.
    /// Range:         [0,unbounded]
    /// Min Length:    1
    /// Max Length:    25
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    UINT32 weightCount;
    UINT32 weightID;
    FLOAT* weight;
};

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/// chromatixLumaTableEntryType
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
struct chromatixLumaTableEntryType
{

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// luma
    ///
    /// Description:   luma value for this entry.
    /// Range:         [0,unbounded]
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    FLOAT luma;

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// weight
    ///
    /// Description:   weight value for this entry.
    /// Range:         [0,unbounded]
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    FLOAT weight;
};

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/// chromatixLumaTableType
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
struct chromatixLumaTableType
{

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// numEntries
    ///
    /// Description:   Number of table entry
    /// Range:         [0,20]
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    UINT32                       numEntries;

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// lumaEntries - Array
    /// Min Length:    1
    /// Max Length:    20
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    UINT32                       lumaEntriesCount;
    UINT32                       lumaEntriesID;
    chromatixLumaTableEntryType* lumaEntries;
};

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/// chromatixFaceTableEntryType
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
struct chromatixFaceTableEntryType
{

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// fvIndex
    ///
    /// Description:   the fv index of this entry.
    /// Range:         [0,unbounded]
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    UINT32 fvIndex;

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// weight
    ///
    /// Description:   weight value for this entry.
    /// Range:         [0,unbounded]
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    FLOAT  weight;
};

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/// chromatixFaceTableType
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
struct chromatixFaceTableType
{

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// numEntries
    ///
    /// Description:   Number of table entry
    /// Range:         [0,20]
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    UINT32                       numEntries;

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// indexEntries - Array
    /// Min Length:    1
    /// Max Length:    20
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    UINT32                       indexEntriesCount;
    UINT32                       indexEntriesID;
    chromatixFaceTableEntryType* indexEntries;
};

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/// chromatixAFWeightedWindowReserveType
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
struct chromatixAFWeightedWindowReserveType
{

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// enableAFRegionWeightTable
    ///
    /// Description:   This flag use to turn on a weighted focus value function which weight is dependent on window position. We
    ///                have multiple window in ROI region. Distance of lens to object has slightly different between each
    ///                window. We want image is as sharp as possible in center ROI region. So we generate a weight to each
    ///                window according to windows position when we measure focus value from each window. Center window will has
    ///                larger weight and border has less weight. This feature only work when ROI region has 5x5 windows.
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    afglobalelements::enable_flag_type         enableAFRegionWeightTable;

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// AFRegionWeightTable
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    chromatixRegionTableType AFRegionWeightTable;

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// enableAFLumaWeightTable
    ///
    /// Description:   This flag use to turn on a weighted focus value function which weight is dependent on luma value. We have
    ///                multiple window in ROI region. Focus value is unreliable in overexposure situation. This function give a
    ///                lower weight to window if it is overexposure when calculating focus value. This feature only work when
    ///                ROI region has 5x5 windows.
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    afglobalelements::enable_flag_type         enableAFLumaWeightTable;

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// AFLumaWeightTable
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    chromatixLumaTableType   AFLumaWeightTable;

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// enableAFFaceWeightTable
    ///
    /// Description:   This flag use to turn on a weighted focus value function which weight is dependent on luma value. We have
    ///                multiple window in ROI region. Focus value is unreliable in overexposure situation. This function give a
    ///                lower weight to window if it is overexposure when calculating focus value. This feature only work when
    ///                ROI region has 5x5 windows.
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    afglobalelements::enable_flag_type         enableAFFaceWeightTable;

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// AFFaceWeightTable
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    chromatixFaceTableType   AFFaceWeightTable;
};

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/// chromatixAFStepBackReserveType
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
struct chromatixAFStepBackReserveType
{

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// stepBackEnable
    ///
    /// Description:   1 is enabled, 0 is disabled. It determines whether 'step back' is enabled by the chromatix, or not. The
    ///                previous way is that the value can be only 1 for closed-loop or 2 for open-loop. But, when the peak is
    ///                near of the current position in pre-scan, it leads lots of several back/forth lens movements trial for
    ///                finding proper peak. Finally, it decreases AF performance. So, this feature makes step back values be
    ///                tunable according to the circumstances. The variation of the step back has 4 cases, and it involves the
    ///                meaning 'direction from'. - Start infinity, Reverse infinity, Start Macro, Reverse Macro.
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    afglobalelements::enable_flag_type stepBackEnable;

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// stepBackStartInfinity
    ///
    /// Description:   Max depending on tuning circumstance. It means how many steps back in case of Start in Infinity. If
    ///                AFChromatixStepBackEnable is 0, it is ignored. Please check with AFChromatixStepBackEnable.
    /// Range:         [0,unbounded]
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    INT32            stepBackStartInfinity;

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// stepBackReverseInfinity
    ///
    /// Description:   Max depending on tuning circumstance. It means how many steps back in case of Reverse in Infinity. If
    ///                AFChromatixStepBackEnable is 0, it is ignored. Please check with AFChromatixStepBackEnable.
    /// Range:         [0,unbounded]
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    INT32            stepBackReverseInfinity;

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// stepBackStartMacro
    ///
    /// Description:   Max depending on tuning circumstance.It means how many steps back in case of start in Macro. If
    ///                AFChromatixStepBackEnable is 0, it is ignored. Please check with AFChromatixStepBackEnable.
    /// Range:         [0,unbounded]
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    INT32            stepBackStartMacro;

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// stepBackReverseMacro
    ///
    /// Description:   Max depending on tuning circumstance.It means how many steps back in case of Reverse in Macro. If
    ///                AFChromatixStepBackEnable is 0, it is ignored. Please check with AFChromatixStepBackEnable.
    /// Range:         [0,unbounded]
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    INT32            stepBackReverseMacro;
};

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/// chromatixAFSecondScanReserveType
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
struct chromatixAFSecondScanReserveType
{

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// fRatioMin
    ///
    /// Description:   Max depending on tuning circumstance.It provides minimum value for comparing ratio during calculating
    ///                second scan range. If it's 0, the fRatio_min is 1.0f. If it's positive number, it's effective.
    /// Range:         [0,unbounded]
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    FLOAT fRatioMin;

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// fRatioMax
    ///
    /// Description:   Max depending on tuning circumstance.It provides maximum value for comparing ratio during calculating
    ///                second scan range. If it's 0, the fRatioMax is 4.0f. If it's positive number, it's effective.
    /// Range:         [0,unbounded]
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    FLOAT fRatioMax;

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// firstPreviousY1
    ///
    /// Description:   Max depending on tuning circumstance.It provides parameter 1st previous Y1 value for comparing ratio
    ///                during calculating second scan range. If it's 0, the fRatio_max is 0.8f. If it's positive number, it's
    ///                effective.
    /// Range:         [0,unbounded]
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    FLOAT firstPreviousY1;

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// nextY1
    ///
    /// Description:   Max depending on tuning circumstance.It provides parameter 1st next Y1 value for comparing ratio during
    ///                calculating second scan range. If it's 0, the fRatio_max is 0.3f. If it's positive number, it's
    ///                effective.
    /// Range:         [0,unbounded]
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    FLOAT nextY1;

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// firstPreviousY2
    ///
    /// Description:   Max depending on tuning circumstance.It provides parameter 1st previous Y2 value for comparing ratio
    ///                during calculating second scan range. If it's 0, the fRatio_max is 0.8f. If it's positive number, it's
    ///                effective.
    /// Range:         [0,unbounded]
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    FLOAT firstPreviousY2;

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// nextY2
    ///
    /// Description:   Max depending on tuning circumstance.It provides parameter 1st next Y2 value for comparing ratio during
    ///                calculating second scan range. If it's 0, the fRatio_max is 0.3f. If it's positive number, it's
    ///                effective.
    /// Range:         [0,unbounded]
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    FLOAT nextY2;

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// secondPreviousY1
    ///
    /// Description:   Max depending on tuning circumstance.It provides parameter 2nd previous Y1 value for comparing ratio
    ///                during calculating second scan range. If it's 0, the fRatio_max is 0.8f. If it's positive number, it's
    ///                effective.
    /// Range:         [0,unbounded]
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    FLOAT secondPreviousY1;

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// secondNextY1
    ///
    /// Description:   Max depending on tuning circumstance.It provides parameter 2nd next Y1 value for comparing ratio during
    ///                calculating second scan range. If it's 0, the fRatio_max is 0.3f. If it's positive number, it's
    ///                effective.
    /// Range:         [0,unbounded]
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    FLOAT secondNextY1;

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// secondPreviousY2
    ///
    /// Description:   Max depending on tuning circumstance.It provides parameter 2nd next Y2 value for comparing ratio during
    ///                calculating second scan range. If it's 0, the fRatio_max is 0.8f. If it's positive number, it's
    ///                effective.
    /// Range:         [0,unbounded]
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    FLOAT secondPreviousY2;

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// secondNextY2
    ///
    /// Description:   Max depending on tuning circumstance.It provides parameter 2nd previous Y2 value for comparing ratio
    ///                during calculating second scan range. If it's 0, the fRatio_max is 0.3f. If it's positive number, it's
    ///                effective.
    /// Range:         [0,unbounded]
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    FLOAT secondNextY2;
};

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/// chromatixAFFlatDetectReserveType
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
struct chromatixAFFlatDetectReserveType
{

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// flatDetectSupportEnable
    ///
    /// Description:   It enables flat curve detection feature. If it's 0 it disables, if it's1 it enables.
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    afglobalelements::enable_flag_type flatDetectSupportEnable;

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// BVThresholdFlatDetect
    ///
    /// Description:   Max depending on tuning circumstance. It's the threshold for BV in case of flat detection. It's valid if
    ///                AFChromatixFlatDetect_SUPPORT is enabled. If not, it's ignored.
    /// Range:         [0,unbounded]
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    FLOAT            BVThresholdFlatDetect;

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// flatIncreasingThreshold
    ///
    /// Description:   Max depending on tuning circumstance. It's the threshold for BV in case of increase pattern.
    /// Range:         [0,unbounded]
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    FLOAT            flatIncreasingThreshold;

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// flatDecreasingThreshold
    ///
    /// Description:   Max depending on tuning circumstance. It's the threshold for BV in case of decrease pattern
    /// Range:         [0,unbounded]
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    FLOAT            flatDecreasingThreshold;
};

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/// chromatixAFSceneChangeBVReserveType
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
struct chromatixAFSceneChangeBVReserveType
{

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// sceneChangeByBVEnable
    ///
    /// Description:   It enables/disables the feature of scene change by BV. It affects the CAF speed performance with added BV
    ///                and FV. It makes AF be reinforced even without gyro and with SAD. Lens is triggered very frequently even
    ///                though scene is changed very slow at the far area. When we made less sensitive for scene change, then CAF
    ///                triggering is very slow.
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    afglobalelements::enable_flag_type sceneChangeByBVEnable;

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// BVUnstableThresholdOutdoor
    ///
    /// Description:   It defined unstable threshold in outdoor. Please check with AFChromatixSceneChangeByBVEnable
    /// Range:         [0,unbounded]
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    FLOAT            BVUnstableThresholdOutdoor;

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// BVStableThresholdOutdoor
    ///
    /// Description:   It defined stable threshold in outdoor. Please check with AFChromatixSceneChangeByBVEnable
    /// Range:         [0,unbounded]
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    FLOAT            BVStableThresholdOutdoor;

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// BVTriggerCountThresholdOutdoor
    ///
    /// Description:   It defined trigger count threshold in outdoor. Please check with AFChromatixSceneChangeByBVEnable
    /// Range:         [0,unbounded]
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    FLOAT            BVTriggerCountThresholdOutdoor;

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// BVUnstableThresholdNormalLux
    ///
    /// Description:   It defined unstable threshold in normal lux. Please check with AFChromatixSceneChangeByBVEnable
    /// Range:         [0,unbounded]
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    FLOAT            BVUnstableThresholdNormalLux;

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// BVStableThresholdNormalLux
    ///
    /// Description:   It defined stable threshold in normal lux. Please check with AFChromatixSceneChangeByBVEnable
    /// Range:         [0,unbounded]
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    FLOAT            BVStableThresholdNormalLux;

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// BVTriggerCountThresholdNormalLux
    ///
    /// Description:   It defined trigger count threshold normal lux. Please check with AFChromatixSceneChangeByBVEnable
    /// Range:         [0,unbounded]
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    FLOAT            BVTriggerCountThresholdNormalLux;

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// BVUnstableThresholdLowLux
    ///
    /// Description:   It defined unstable threshold in low lux. Please check with AFChromatixSceneChangeByBVEnable
    /// Range:         [0,unbounded]
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    FLOAT            BVUnstableThresholdLowLux;

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// BVStableThresholdLowLux
    ///
    /// Description:   It defined stable threshold in low lux. Please check with AFChromatixSceneChangeByBVEnable
    /// Range:         [0,unbounded]
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    FLOAT            BVStableThresholdLowLux;

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// BVTriggerCountThresholdLowLux
    ///
    /// Description:   It defined trigger count threshold in low lux. Please check with AFChromatixSceneChangeByBVEnable
    /// Range:         [0,unbounded]
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    FLOAT            BVTriggerCountThresholdLowLux;
};

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/// AFStatisticComputationType
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
enum class AFStatisticComputationType
{
    AF_StatsH1          = 0,
    AFStatsH1_NORM      = 1,
    AF_StatsH2          = 2,
    AFStatsH2_NORM      = 3,
    AF_Stats_V          = 4,
    AFStats_V_NORM      = 5,
    AF_Stats_HV         = 6,
    AF_Stats_HV_NORM    = 7,
    AF_Stats_Scale      = 8,
    AF_Stats_Scale_NORM = 9,
    AF_Stats_MAX        = 10
};

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/// chromatixAFHVStatWeightReserveType
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
struct chromatixAFHVStatWeightReserveType
{

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// enableHVStatsRatio
    ///
    /// Description:   A switch to enable weighted focus value. Focus value will be H_weight*H+(1-H_weight)*V if this flag set
    ///                to 1.
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    afglobalelements::enable_flag_type enableHVStatsRatio;

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// hvFocusValueWeight
    ///
    /// Description:   Weight of H focus value and V focus value. Focus value will be H_weight*H+(1-H_weight)*V in horizontal
    ///                and (1-H_weight)*H+H_weight*V in horizontal in portrait.
    /// Range:         [0,1]
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    FLOAT            hvFocusValueWeight;
};

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/// chromatixContrastAFType
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
struct chromatixContrastAFType
{
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// Binary file symbol table entry ID
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    UINT32 SymbolTableID;

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// module_version
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    struct module_versionStruct
    {
        ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
        /// Binary file symbol table entry ID
        ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
        UINT32 SymbolTableID;
        INT32 major_revision;
        INT32 minor_revision;
    } module_version;

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// parameter_version
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    struct parameter_versionStruct
    {
        ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
        /// Binary file symbol table entry ID
        ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
        UINT32 SymbolTableID;
        INT32 major_revision;
        INT32 minor_revision;
    } parameter_version;

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// statisticsSelection
    ///
    /// Description:   Select H1/H2/V/HV (norm) stats to use for algo Constraints
    /// Range:         [0,9]
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    AFStatisticComputationType           statisticsSelection;

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// fullSweep
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    chromatixAFTuningFullsweep           fullSweep;

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// singleSearch
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    chromatixAFTuningSingle              singleSearch;

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// spotlightTuning
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    chromatixAFSpotlightReserveType      spotlightTuning;

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// weightedWindow
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    chromatixAFWeightedWindowReserveType weightedWindow;

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// exposureCompensation
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    chromatixBAFExposureCompensation     exposureCompensation;

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// HVFocusValueStatisticWeighting
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    chromatixAFHVStatWeightReserveType   HVFocusValueStatisticWeighting;

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// stepBack
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    chromatixAFStepBackReserveType       stepBack;

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// secondScan
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    chromatixAFSecondScanReserveType     secondScan;

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// flatnessDetection
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    chromatixAFFlatDetectReserveType     flatnessDetection;

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// sceneChangeBV
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    chromatixAFSceneChangeBVReserveType  sceneChangeBV;

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// miscellaneous
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    chromatixAFMiscellaneousType         miscellaneous;
};

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/// chromatixContrastAFTypeClass
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
class chromatixContrastAFTypeClass : public ParameterModule, public chromatixContrastAFType
{
public:
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// Version
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    static const UINT16 MAJOR = 3;
    static const UINT16 MINOR = 4;
    static const UINT32 PATCH = 0;

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// Default Constructor
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    chromatixContrastAFTypeClass(
        const CHAR* name);

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// Constructor
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    chromatixContrastAFTypeClass(
        const CHAR* name,
        UINT32 modeId,
        UINT16 mode,
        UINT16 subMode,
        UINT32 group);

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// Destructor
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    virtual ~chromatixContrastAFTypeClass();

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// GetName
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    static const CHAR* GetName(
        const CHAR* type);


    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// Load chromatixBAFExposureCompensation
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    static BOOL LoadchromatixBAFExposureCompensation(
        ParameterFileSymbolTableEntry* entry,
        chromatixBAFExposureCompensation* structure);

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// Load chromatixAFMiscellaneousType
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    static BOOL LoadchromatixAFMiscellaneousType(
        ParameterFileSymbolTableEntry* entry,
        chromatixAFMiscellaneousType* structure);

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// Load chromatixAFTuningFullsweep
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    static BOOL LoadchromatixAFTuningFullsweep(
        ParameterFileSymbolTableEntry* entry,
        chromatixAFTuningFullsweep* structure);

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// Load chromatixStepSize
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    static BOOL LoadchromatixStepSize(
        ParameterFileSymbolTableEntry* entry,
        chromatixStepSize* structure);

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// Load chromatixStepSizeTable
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    static BOOL LoadchromatixStepSizeTable(
        ParameterFileSymbolTableEntry* entry,
        chromatixStepSizeTable* structure);

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// Load chromatixBVThreshold
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    static BOOL LoadchromatixBVThreshold(
        ParameterFileSymbolTableEntry* entry,
        chromatixBVThreshold* structure);

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// Load chromatixSingleThreshold
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    static BOOL LoadchromatixSingleThreshold(
        ParameterFileSymbolTableEntry* entry,
        chromatixSingleThreshold* structure);

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// Load chromatixFVScoreThreshold
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    static BOOL LoadchromatixFVScoreThreshold(
        ParameterFileSymbolTableEntry* entry,
        chromatixFVScoreThreshold* structure);

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// Load chromatixSingleOptic
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    static BOOL LoadchromatixSingleOptic(
        ParameterFileSymbolTableEntry* entry,
        chromatixSingleOptic* structure);

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// Load chromatixAFSingleFrameDelay
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    static BOOL LoadchromatixAFSingleFrameDelay(
        ParameterFileSymbolTableEntry* entry,
        chromatixAFSingleFrameDelay* structure);

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// Load chromatixAFTuningSingle
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    static BOOL LoadchromatixAFTuningSingle(
        ParameterFileSymbolTableEntry* entry,
        chromatixAFTuningSingle* structure);

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// Load chromatixAFSpotlightReserveType
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    static BOOL LoadchromatixAFSpotlightReserveType(
        ParameterFileSymbolTableEntry* entry,
        chromatixAFSpotlightReserveType* structure);

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// Load chromatixRegionTableType
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    static BOOL LoadchromatixRegionTableType(
        ParameterFileSymbolTableEntry* entry,
        chromatixRegionTableType* structure);

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// Load chromatixLumaTableEntryType
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    static BOOL LoadchromatixLumaTableEntryType(
        ParameterFileSymbolTableEntry* entry,
        chromatixLumaTableEntryType* structure);

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// Load chromatixLumaTableType
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    static BOOL LoadchromatixLumaTableType(
        ParameterFileSymbolTableEntry* entry,
        chromatixLumaTableType* structure);

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// Load chromatixFaceTableEntryType
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    static BOOL LoadchromatixFaceTableEntryType(
        ParameterFileSymbolTableEntry* entry,
        chromatixFaceTableEntryType* structure);

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// Load chromatixFaceTableType
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    static BOOL LoadchromatixFaceTableType(
        ParameterFileSymbolTableEntry* entry,
        chromatixFaceTableType* structure);

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// Load chromatixAFWeightedWindowReserveType
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    static BOOL LoadchromatixAFWeightedWindowReserveType(
        ParameterFileSymbolTableEntry* entry,
        chromatixAFWeightedWindowReserveType* structure);

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// Load chromatixAFStepBackReserveType
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    static BOOL LoadchromatixAFStepBackReserveType(
        ParameterFileSymbolTableEntry* entry,
        chromatixAFStepBackReserveType* structure);

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// Load chromatixAFSecondScanReserveType
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    static BOOL LoadchromatixAFSecondScanReserveType(
        ParameterFileSymbolTableEntry* entry,
        chromatixAFSecondScanReserveType* structure);

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// Load chromatixAFFlatDetectReserveType
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    static BOOL LoadchromatixAFFlatDetectReserveType(
        ParameterFileSymbolTableEntry* entry,
        chromatixAFFlatDetectReserveType* structure);

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// Load chromatixAFSceneChangeBVReserveType
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    static BOOL LoadchromatixAFSceneChangeBVReserveType(
        ParameterFileSymbolTableEntry* entry,
        chromatixAFSceneChangeBVReserveType* structure);

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// Load chromatixAFHVStatWeightReserveType
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    static BOOL LoadchromatixAFHVStatWeightReserveType(
        ParameterFileSymbolTableEntry* entry,
        chromatixAFHVStatWeightReserveType* structure);

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// Load chromatixContrastAFType
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    static BOOL LoadchromatixContrastAFType(
        ParameterFileSymbolTableEntry* entry,
        chromatixContrastAFType* structure);

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// Load module_versionStruct
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    static BOOL Loadmodule_versionStruct(
        ParameterFileSymbolTableEntry* entry,
        chromatixContrastAFType::module_versionStruct* structure);

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// Load parameter_versionStruct
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    static BOOL Loadparameter_versionStruct(
        ParameterFileSymbolTableEntry* entry,
        chromatixContrastAFType::parameter_versionStruct* structure);

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// Unload chromatixAFTuningSingle
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    static void UnloadchromatixAFTuningSingle(
        chromatixAFTuningSingle* structure);

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// Unload chromatixRegionTableType
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    static void UnloadchromatixRegionTableType(
        chromatixRegionTableType* structure);

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// Unload chromatixLumaTableType
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    static void UnloadchromatixLumaTableType(
        chromatixLumaTableType* structure);

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// Unload chromatixFaceTableType
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    static void UnloadchromatixFaceTableType(
        chromatixFaceTableType* structure);

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// Unload chromatixAFWeightedWindowReserveType
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    static void UnloadchromatixAFWeightedWindowReserveType(
        chromatixAFWeightedWindowReserveType* structure);

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// Unload chromatixContrastAFType
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    static void UnloadchromatixContrastAFType(
        chromatixContrastAFType* structure);

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// Parse symbol table entry, and return a new object
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    virtual ParameterModule* Parse(
        ParameterSetManager* manager,
        ParameterFileSymbolTableEntry* entry) const;

}; // End class chromatixContrastAFTypeClass

AFCONTRASTAFELEMENTS_NAMESPACE_END
#endif // AFCONTRASTAFELEMENTS_H

